// #ifndef _HTTPDATA_H
// #define _HTTPDATA_H

// #include "Channel.h"
// #include "DDAP.pb.h"
// #include "ECCOper.h"
// #include "EventLoop.h"
// #include "SymmetricEncryption.h"
// #include "blockchainoperator.h"
// #include "utils.h"

// #include <cstddef>
// #include <functional>
// #include <map>
// #include <memory>
// #include <openssl/types.h>
// #include <pthread.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string>
// #include <sys/epoll.h>
// #include <unistd.h>
// #include <unordered_map>

// namespace droneswarm
// {
//     //每个消息的发送为了保证数据的完整性和不被篡改并检验是否是具有会话密钥的对等体发送的数据，因此使用HMAC来检查。
//     //因此都是发送的NEEDHMACMESSAGE消息

//     class TimerNode;
//     enum ProcessState  //处理阶段的枚举
//     {
//         STATE_PARSE_NEEDHMACMESSAGE = 1,  //解析NEEDHMACMESSAGE消息
//         STATE_PARSE_ENCRYPTMESSAGE,       //解析ENCRYPTMESSAGE消息
//         STATE_PARSE_FULLMESSAGE,          //解析FULLMESSAGE消息
//         STATE_MESSAGEINFO_ANALYSIS,       //分析MESSAGEINFO结构体阶段
//         STATE_MESSAGE_FINSH               //完成处理阶段
//     };

//     //定义解析URI的不同阶段的枚举
//     enum NEEDHMACMESSAGEState
//     {
//         PARSE_NEEDHMACMESSAGE_AGAIN = 1,  //再次解析NEEDHMACMESSAGE
//         PARSE_NEEDHMACMESSAGE_ERROR,      //解析NEEDHMACMESSAGE出错
//         PARSE_NEEDHMACMESSAGE_SUCESS      //解析NEEDHMACMESSAGE成功
//     };

//     enum ENCRYPTMESSAGEState
//     {
//         PARSE_ENCRYPTMESSAGE_ERROR = 1,  //解析ENCRYPTMESSAGE出错
//         PARSE_ENCRYPTMESSAGE_SUCESS      //解析ENCRYPTMESSAGE成功
//     };

//     enum FULLMESSAGEState
//     {
//         PARSE_FULLMESSAGE_ERROR = 1,  //解析FULLMESSAGE出错
//         PARSE_FULLMESSAGE_SUCESS      //解析FULLMESSAGE成功
//     };

//     enum MESSAGEINFOState
//     {
//         PARSE_MESSAGEINFO_ERROR = 1,
//         PARSE_MESSAGEINFO_SUCESS
//     };

//     enum LineState
//     {
//         PARSE_LINE_ERROR = 1,  //解析Line出错
//         PARSE_LINE_SUCESS      //解析Line成功
//     };

//     //定义解析DDAP消息头的不同状态
//     enum HeaderState
//     {
//         PARSE_HEADER_SUCESS = 1,  //解析成功
//         PARSE_HEADER_ERROR        //解析出错
//     };

//     //定义DDAP解析状态的枚举
//     enum AnalysisState
//     {
//         ANALYSIS_SUCCESS = 1,
//         ANALYSIS_ERROR
//     };

//     //定义HTTP请求头部解析过程中的不同阶段。
//     // HTTP请求头部由键值对组成，key和value用:分隔。
//     enum ParseState
//     {
//         H_START = 0,  //起始状态，表示开始解析一个新的头部字段
//         H_KEY,
//         H_COLON,              //解析头部字段名后的冒号的状态，通常头部冒号后面会跟一个空格
//         H_SPACES_AFER_COLON,  //解析冒号后面的空格状态
//         H_VALUE,              //解析value的状态
//         H_CR,                 //解析回车符的状态
//         H_LF,                 //解析换行符的状态
//         H_END_CR,             //解析消息头部结束的回车符的状态
//         H_END_LF              //解析消息头部结束的换行符的状态
//     };

//     enum ConnectionState
//     {
//         H_CONNECTED = 0,  //表示连接已经建立
//         H_DISCONNECTING,  //表示正在断开连接
//         H_DISCONNECTED    //表示连接已经断开
//     };

//     enum HttpMethod
//     {
//         METHOD_POST = 1,  //表示HTTP的POST请求，通常用于提交数据到服务器。
//         METHOD_GET,       //表示HTTP的GET请求，通常用于从服务器获取数据。
//         METHOD_HEAD  //表示HTTP的HEAD请求，通常用于获取资源的元信息，如头信息，但不返回实体主体。
//     };

//     enum HttpVersion
//     {
//         HTTP_10 = 1,
//         HTTP_11
//     };

//     class MimeType
//     {
//     private:
//         static void init();
//         static std::unordered_map< std::string, std::string > mime;
//         MimeType();
//         MimeType( const MimeType &m );

//     public:
//         static std::string getMime( const std::string &suffix );

//     private:
//         static pthread_once_t once_control;
//     };

//     // std::enable_shared_from_this<HttpData>模板类，继承这个模板类的类，可以使用
//     // shared_from_this()方法获取一个指向自身的std::shared_ptr 对象。
//     //继承 std::enable_shared_from_this 通常用于在类内部需要将自身作为 std::shared_ptr
//     //参数传递给其他函数或者对象的情况下，以确保对象的生命周期管理正确。
//     class Ddap : public std::enable_shared_from_this< Ddap >
//     {
//     public:
//         Ddap( EventLoop *loop, int fd, unsigned char symmetricKey[ 32 ] );
//         ~Ddap();
//         void reset();                                                               //
//         void seperateTimer();                                                       // 分离计时器
//         void linkTimer( std::shared_ptr< TimerNode > mtimer ) { timer_ = mtimer; }  // 关联计时器
//         std::shared_ptr< Channel > getChannel() { return channel_; }
//         EventLoop *getLoop() { return loop_; }
//         void handleClose();
//         void newEvent();

//     private:
//         EventLoop *loop_;
//         std::shared_ptr< Channel > channel_;
//         int fd_;
//         std::string inBuffer_;
//         std::string outBuffer_;
//         bool error_;
//         int parseMsgCount;
//         BlockChainOperator bco_;
//         needHMACMessage needHmacMsg_;
//         EncrptyMessage encryptMsg_;
//         SigningMessage signingMsg_;
//         FullMessage fullMsg_;
//         unsigned char plainText_[ 4096 ];
//         unsigned char cipherText_[ 4096 ];
//         size_t cipherTextLen_;
//         int plainTextLen_;
//         SymmetricEncryption symm_;
//         messageInfo msgInfo_;
//         ConnectionState connectionState_;  // 连接状态
//         MessageType msgType_;              // HTTP 请求方法
//         std::string DdapVersion_;          // HTTP 版本
//         int nowReadPos_;                   // 当前读取位置
//         ProcessState state_;               // 处理阶段状态

//         bool keepAlive_;                    // 保持连接标志
//         std::weak_ptr< TimerNode > timer_;  // 计时器，用于管理超时
//         void handleRead();
//         void handleWrite();
//         void handleConn();  //这个具体的函数绑定到了channel类的handleConn函数中，每次在处理完
//         void handleError( int fd, int err_num, std::string short_msg );
//         NEEDHMACMESSAGEState parseNeedHmacMessage();
//         ENCRYPTMESSAGEState parseEncryptMessage();
//         FULLMESSAGEState parseFullMessage();
//         LineState parseLine();            // 解析 URI
//         HeaderState parseHeaders();       // 解析头部
//         AnalysisState analysisMessage();  // 分析请求体
//         std::vector< DroneData > parseDroneData( std::string data );
//         bool constructProtobufMessage( MessageType mt, std::string );
//         //加密操作对象
//         ECCOperator eccOp_;
//         //对称密钥
//         unsigned char symmetricKey_[ 32 ];
//         //接收方的EVP_PKEY 公钥需要传递进来
//         // EVP_PKEY *senderPubKey_;
//     };
// }  // namespace droneswarm
// #endif